﻿///////////////////////////////////////////////////////////////
// This is generated code. If you modify this code, be aware
// of the fact that when you re-generate the code, your changes
// are lost. If you want to keep your changes, make this file read-only
// when you have finished your changes, however it is recommended that
// you inherit from this class to extend the functionality of this generated
// class or you modify / extend the templates used to generate this code.
//////////////////////////////////////////////////////////////
// Code is generated using LLBLGen Pro version: 1.0.2005.1
// Code is generated on: October 21, 2008 12:02:20 AM
// Code is generated using templates: C# template set for SqlServer (1.0.2005.1)
// Templates vendor: Solutions Design.
// Templates version: 1.0.2005.1.111705
//////////////////////////////////////////////////////////////
using System;
using System.ComponentModel;
using System.Data;
using System.Collections;
using System.Runtime.Serialization;

using Ultimate.DAL.HelperClasses;
using Ultimate.DAL.DaoClasses;
using Ultimate.DAL.EntityClasses;
using Ultimate.DAL.FactoryClasses;

using SD.LLBLGen.Pro.ORMSupportClasses;

namespace Ultimate.DAL.TypedListClasses
{
	
	// __LLBLGENPRO_USER_CODE_REGION_START AdditionalNamespaces
	// __LLBLGENPRO_USER_CODE_REGION_END

	/// <summary>
	/// Typed datatable for the list 'FieldLocation'.<br/><br/>
	/// </summary>
	/// <remarks>
	/// It embeds a fill method which accepts a filter.
	/// The code doesn't support any changing of data. Users who do that are on their own.
	/// It also doesn't support any event throwing. This list should be used as a base for readonly databinding
	/// or dataview construction.
	/// </remarks>
#if !CF	
	[Serializable, System.ComponentModel.DesignerCategory("Code")]
	[ToolboxItem(true)]
	[DesignTimeVisible(true)]
#endif	
	public partial class FieldLocationTypedList : TypedListBase, IEnumerable, ITypedListLgp
		// __LLBLGENPRO_USER_CODE_REGION_START AdditionalInterfacesList
		// __LLBLGENPRO_USER_CODE_REGION_END	
	{
		#region Class Member Declarations
		private DataColumn _columnFieldID;
		private DataColumn _columnFieldName;
		private DataColumn _columnQuality;
		private DataColumn _columnDescription;
		private DataColumn _columnName;
		private DataColumn _columnNumberOfFields;
		private DataColumn _columnAddress;
		private DataColumn _columnLocationID;
		
		// __LLBLGENPRO_USER_CODE_REGION_START AdditionalMembers
		// __LLBLGENPRO_USER_CODE_REGION_END
		private static Hashtable	_customProperties;
		private static Hashtable	_fieldsCustomProperties;
		#endregion

		#region Class Constants
		/// <summary>The amount of fields in the resultset.</summary>
		private const int AmountOfFields = 8;
		#endregion


		/// <summary>Static CTor for setting up custom property hashtables. Is executed before the first instance of this
		/// class or derived classes is constructed. </summary>
		static FieldLocationTypedList()
		{
			SetupCustomPropertyHashtables();
		}
		
		/// <summary>CTor</summary>
		public FieldLocationTypedList():base("FieldLocation")
		{
			InitClass(false);
		}
		
		
		/// <summary>CTor</summary>
		/// <param name="obeyWeakRelations">The flag to signal the collection what kind of join statements to generate in the
		/// query statement. Weak relationships are relationships which are optional, for example a
		/// customer with no orders is possible, because the relationship between customer and order is based on a field in order.
		/// When this property is set to true (default: false), weak relationships will result in LEFT JOIN statements. When
		/// set to false (which is the default), INNER JOIN statements are used.
		/// </param>
		public FieldLocationTypedList(bool obeyWeakRelations):base("FieldLocation")
		{
			InitClass(obeyWeakRelations);
		}
		
#if !CF	
		/// <summary>Protected constructor for deserialization.</summary>
		/// <param name="info"></param>
		/// <param name="context"></param>
		protected FieldLocationTypedList(SerializationInfo info, StreamingContext context):base(info, context)
		{
			InitMembers();
		}
#endif		
		
		/// <summary>Fills itself with data. it builds a dynamic query and loads itself with that query. 
		/// Will use no sort filter, no select filter, will allow duplicate rows and will not limit the amount of rows returned</summary>
		/// <returns>true if fill succeeded, false otherwise</returns>
		public bool Fill()
		{
			return Fill(0, null, true, null, null, null, 0, 0);
		}


		/// <summary>Fills itself with data. it builds a dynamic query and loads itself with that query. 
		/// Will not use a filter, will allow duplicate rows.</summary>
		/// <param name="maxNumberOfItemsToReturn">The maximum amount of rows to return. specifying 0 means all rows are returned</param>
		/// <param name="sortClauses">The order by specifications for the sorting of the resultset. When null is specified, no sorting is applied.</param>
		/// <returns>true if fill succeeded, false otherwise</returns>
		public bool Fill(long maxNumberOfItemsToReturn, ISortExpression sortClauses)
		{
			return Fill(maxNumberOfItemsToReturn, sortClauses, true, null, null, null, 0, 0);
		}


		/// <summary>Fills itself with data. it builds a dynamic query and loads itself with that query. 
		/// Will not use a filter.</summary>
		/// <param name="maxNumberOfItemsToReturn">The maximum amount of rows to return. specifying 0 means all rows are returned</param>
		/// <param name="sortClauses">The order by specifications for the sorting of the resultset. When null is specified, no sorting is applied.</param>
		/// <param name="allowDuplicates">Flag to allow duplicate rows (true) or not (false)</param>
		/// <returns>true if fill succeeded, false otherwise</returns>
		public bool Fill(long maxNumberOfItemsToReturn, ISortExpression sortClauses, bool allowDuplicates)
		{
			return Fill(maxNumberOfItemsToReturn, sortClauses, allowDuplicates, null, null, null, 0, 0);
		}


		/// <summary>Fills itself with data. it builds a dynamic query and loads itself with that query, using the specified filter</summary>
		/// <param name="maxNumberOfItemsToReturn">The maximum amount of rows to return. specifying 0 means all rows are returned</param>
		/// <param name="sortClauses">The order by specifications for the sorting of the resultset. When null is specified, no sorting is applied.</param>
		/// <param name="allowDuplicates">Flag to allow duplicate rows (true) or not (false)</param>
		/// <param name="selectFilter">Predicate which is used to filter the rows to insert in this Typed List instance</param>
		/// <returns>true if fill succeeded, false otherwise</returns>
		public virtual bool Fill(long maxNumberOfItemsToReturn, ISortExpression sortClauses, bool allowDuplicates, IPredicate selectFilter)
		{
			return Fill(maxNumberOfItemsToReturn, sortClauses, allowDuplicates, selectFilter, null, null, 0, 0);
		}


		/// <summary>Fills itself with data. it builds a dynamic query and loads itself with that query, using the specified filter</summary>
		/// <param name="maxNumberOfItemsToReturn">The maximum amount of rows to return. specifying 0 means all rows are returned</param>
		/// <param name="sortClauses">The order by specifications for the sorting of the resultset. When null is specified, no sorting is applied.</param>
		/// <param name="allowDuplicates">Flag to allow duplicate rows (true) or not (false)</param>
		/// <param name="selectFilter">Predicate which is used to filter the rows to insert in this Typed List instance</param>
		/// <param name="transactionToUse">The transaction object to use. Can be null. If specified, the connection object of the transaction is
		/// used to fill the TypedView, which avoids deadlocks on SqlServer.</param>
		/// <returns>true if fill succeeded, false otherwise</returns>
		public bool Fill(long maxNumberOfItemsToReturn, ISortExpression sortClauses, bool allowDuplicates, IPredicate selectFilter, ITransaction transactionToUse)
		{
			return Fill(maxNumberOfItemsToReturn, sortClauses, allowDuplicates, selectFilter, transactionToUse, null, 0, 0);
		}


		/// <summary>Fills itself with data. it builds a dynamic query and loads itself with that query, using the specified filter</summary>
		/// <param name="maxNumberOfItemsToReturn">The maximum amount of rows to return. specifying 0 means all rows are returned</param>
		/// <param name="sortClauses">The order by specifications for the sorting of the resultset. When null is specified, no sorting is applied.</param>
		/// <param name="allowDuplicates">Flag to allow duplicate rows (true) or not (false)</param>
		/// <param name="selectFilter">Predicate which is used to filter the rows to insert in this Typed List instance</param>
		/// <param name="transactionToUse">The transaction object to use. Can be null. If specified, the connection object of the transaction is
		/// used to fill the TypedView, which avoids deadlocks on SqlServer.</param>
		/// <param name="groupByClause">GroupByCollection with fields to group by on.</param>
		/// <returns>true if fill succeeded, false otherwise</returns>
		public bool Fill(long maxNumberOfItemsToReturn, ISortExpression sortClauses, bool allowDuplicates, IPredicate selectFilter, ITransaction transactionToUse, 
			IGroupByCollection groupByClause)
		{
			return Fill(maxNumberOfItemsToReturn, sortClauses, allowDuplicates, selectFilter, transactionToUse, groupByClause, 0, 0);
		}


		/// <summary>Fills itself with data. it builds a dynamic query and loads itself with that query, using the specified filter</summary>
		/// <param name="maxNumberOfItemsToReturn">The maximum amount of rows to return. specifying 0 means all rows are returned</param>
		/// <param name="sortClauses">The order by specifications for the sorting of the resultset. When null is specified, no sorting is applied.</param>
		/// <param name="allowDuplicates">Flag to allow duplicate rows (true) or not (false)</param>
		/// <param name="selectFilter">Predicate which is used to filter the rows to insert in this Typed List instance</param>
		/// <param name="transactionToUse">The transaction object to use. Can be null. If specified, the connection object of the transaction is
		/// used to fill the TypedView, which avoids deadlocks on SqlServer.</param>
		/// <param name="groupByClause">GroupByCollection with fields to group by on.</param>
		/// <param name="pageNumber">The page number to retrieve.</param>
		/// <param name="pageSize">The page size of the page to retrieve.</param>
		/// <returns>true if fill succeeded, false otherwise</returns>
		public virtual bool Fill(long maxNumberOfItemsToReturn, ISortExpression sortClauses, bool allowDuplicates, IPredicate selectFilter, ITransaction transactionToUse, 
			IGroupByCollection groupByClause, int pageNumber, int pageSize)
		{
			IEntityFields fieldsInResultset = BuildResultset();
			IRelationCollection relations = BuildRelationSet();

			TypedListDAO dao = DAOFactory.CreateTypedListDAO();
			return dao.GetMultiAsDataTable(fieldsInResultset, this, maxNumberOfItemsToReturn, sortClauses, selectFilter, relations, allowDuplicates, groupByClause, transactionToUse, pageNumber, pageSize);
		}


		/// <summary>Gets the amount of rows in the database for this typed list, not skipping duplicates</summary>
		/// <returns>the number of rows in the set defined by the passed in query elements</returns>
		public int GetDbCount()
		{
			return GetDbCount(true, null, null);
		}
		
		
		/// <summary>Gets the amount of rows in the database for this typed list.</summary>
		/// <param name="allowDuplicates">Flag to allow duplicate rows (true) or not (false)</param>
		/// <returns>the number of rows in the set defined by the passed in query elements</returns>
		public int GetDbCount(bool allowDuplicates)
		{
			return GetDbCount(allowDuplicates, null, null);
		}


		/// <summary>Gets the amount of rows in the database for this typed list.</summary>
		/// <param name="allowDuplicates">Flag to allow duplicate rows (true) or not (false)</param>
		/// <param name="filter">The filter to apply for the count retrieval</param>
		/// <returns>the number of rows in the set defined by the passed in query elements</returns>
		public int GetDbCount(bool allowDuplicates, IPredicateExpression filter)
		{
			return GetDbCount(allowDuplicates, filter, null);
		}

		
		/// <summary>Gets the amount of rows in the database for this typed list.</summary>
		/// <param name="allowDuplicates">Flag to allow duplicate rows (true) or not (false)</param>
		/// <param name="filter">The filter to apply for the count retrieval</param>
		/// <param name="relations">The relations for the filter to apply</param>
		/// <returns>the number of rows in the set defined by the passed in query elements</returns>
		public int GetDbCount(bool allowDuplicates, IPredicateExpression filter, IRelationCollection relations)
		{
			return GetDbCount(allowDuplicates, filter, relations, null);
		}


		/// <summary>Gets the amount of rows in the database for this typed list.</summary>
		/// <param name="allowDuplicates">Flag to allow duplicate rows (true) or not (false)</param>
		/// <param name="filter">The filter to apply for the count retrieval</param>
		/// <param name="relations">The relations for the filter to apply</param>
		/// <param name="groupByClause">group by clause to embed in the query</param>
		/// <returns>the number of rows in the set defined by the passed in query elements</returns>
		public virtual int GetDbCount(bool allowDuplicates, IPredicateExpression filter, IRelationCollection relations, GroupByCollection groupByClause)
		{
			IEntityFields fieldsInResultset = BuildResultset();
			IRelationCollection relationsToUse = BuildRelationSet();
			if(relations!=null)
			{
				for (int i = 0; i < relations.Count; i++)
				{
					relationsToUse.Add(relations[i]);
				}
			}

			TypedListDAO dao = DAOFactory.CreateTypedListDAO();
			return dao.GetDbCount(fieldsInResultset, null, filter, relationsToUse, groupByClause, allowDuplicates);
		}


		/// <summary>Gets the enumerator for this class.</summary>
		/// <returns>Enumerator for this class.</returns>
		public IEnumerator GetEnumerator()
		{
			return this.Rows.GetEnumerator();
		}


		/// <summary>Builds the relation set for this typed list.</summary>
		/// <returns>ready to use relation set</returns>
		public virtual IRelationCollection BuildRelationSet()
		{
			IRelationCollection toReturn = new RelationCollection();
			toReturn.ObeyWeakRelations = base.ObeyWeakRelations;
			toReturn.Add(FieldEntity.Relations.LocationEntityUsingLocationID, "", "", JoinHint.None);
			
			// __LLBLGENPRO_USER_CODE_REGION_START AdditionalRelations
			// __LLBLGENPRO_USER_CODE_REGION_END
			return toReturn;
		}


		/// <summary>Builds the resultset fields.</summary>
		/// <returns>ready to use resultset</returns>
		public virtual IEntityFields BuildResultset()
		{
			ResultsetFields toReturn = new ResultsetFields(AmountOfFields);
			toReturn.DefineField(FieldFieldIndex.FieldID, 0, "FieldID", "", AggregateFunction.None);
			toReturn.DefineField(FieldFieldIndex.FieldName, 1, "FieldName", "", AggregateFunction.None);
			toReturn.DefineField(FieldFieldIndex.Quality, 2, "Quality", "", AggregateFunction.None);
			toReturn.DefineField(FieldFieldIndex.Description, 3, "Description", "", AggregateFunction.None);
			toReturn.DefineField(LocationFieldIndex.Name, 4, "Name", "", AggregateFunction.None);
			toReturn.DefineField(LocationFieldIndex.NumberOfFields, 5, "NumberOfFields", "", AggregateFunction.None);
			toReturn.DefineField(LocationFieldIndex.Address, 6, "Address", "", AggregateFunction.None);
			toReturn.DefineField(LocationFieldIndex.LocationID, 7, "LocationID", "", AggregateFunction.None);
			
			// __LLBLGENPRO_USER_CODE_REGION_START AdditionalFields
			// be sure to call toReturn.Expand(number of new fields) first. 
			// __LLBLGENPRO_USER_CODE_REGION_END
			return toReturn;
		}


		/// <summary>Creates a new typed row during the build of the datatable during a Fill session by a dataadapter.</summary>
		/// <param name="rowBuilder">supplied row builder to pass to the typed row</param>
		/// <returns>the new typed datarow</returns>
		protected override DataRow NewRowFromBuilder(DataRowBuilder rowBuilder) 
		{
			return new FieldLocationRow(rowBuilder);
		}


		/// <summary>Initializes the hashtables for the typed list type and typed list field custom properties. </summary>
		private static void SetupCustomPropertyHashtables()
		{
			_customProperties = new Hashtable();
			_fieldsCustomProperties = new Hashtable();

			Hashtable fieldHashtable = null;

			fieldHashtable = new Hashtable();

			_fieldsCustomProperties.Add("FieldID", fieldHashtable);
			fieldHashtable = new Hashtable();

			_fieldsCustomProperties.Add("FieldName", fieldHashtable);
			fieldHashtable = new Hashtable();

			_fieldsCustomProperties.Add("Quality", fieldHashtable);
			fieldHashtable = new Hashtable();

			_fieldsCustomProperties.Add("Description", fieldHashtable);
			fieldHashtable = new Hashtable();

			_fieldsCustomProperties.Add("Name", fieldHashtable);
			fieldHashtable = new Hashtable();

			_fieldsCustomProperties.Add("NumberOfFields", fieldHashtable);
			fieldHashtable = new Hashtable();

			_fieldsCustomProperties.Add("Address", fieldHashtable);
			fieldHashtable = new Hashtable();

			_fieldsCustomProperties.Add("LocationID", fieldHashtable);			
		}


		/// <summary>Initialize the datastructures.</summary>
		/// <param name="obeyWeakRelations">flag for the internal used relations object</param>
		private void InitClass(bool obeyWeakRelations)
		{
			
			_columnFieldID = new DataColumn("FieldID", typeof(System.Int32), null, MappingType.Element);
			_columnFieldID.ReadOnly = true;
			_columnFieldID.Caption = @"FieldID";
			this.Columns.Add(_columnFieldID);

			_columnFieldName = new DataColumn("FieldName", typeof(System.String), null, MappingType.Element);
			_columnFieldName.ReadOnly = true;
			_columnFieldName.Caption = @"FieldName";
			this.Columns.Add(_columnFieldName);

			_columnQuality = new DataColumn("Quality", typeof(System.Int32), null, MappingType.Element);
			_columnQuality.ReadOnly = true;
			_columnQuality.Caption = @"Quality";
			this.Columns.Add(_columnQuality);

			_columnDescription = new DataColumn("Description", typeof(System.String), null, MappingType.Element);
			_columnDescription.ReadOnly = true;
			_columnDescription.Caption = @"Description";
			this.Columns.Add(_columnDescription);

			_columnName = new DataColumn("Name", typeof(System.String), null, MappingType.Element);
			_columnName.ReadOnly = true;
			_columnName.Caption = @"Name";
			this.Columns.Add(_columnName);

			_columnNumberOfFields = new DataColumn("NumberOfFields", typeof(System.Int32), null, MappingType.Element);
			_columnNumberOfFields.ReadOnly = true;
			_columnNumberOfFields.Caption = @"NumberOfFields";
			this.Columns.Add(_columnNumberOfFields);

			_columnAddress = new DataColumn("Address", typeof(System.String), null, MappingType.Element);
			_columnAddress.ReadOnly = true;
			_columnAddress.Caption = @"Address";
			this.Columns.Add(_columnAddress);

			_columnLocationID = new DataColumn("LocationID", typeof(System.Int32), null, MappingType.Element);
			_columnLocationID.ReadOnly = true;
			_columnLocationID.Caption = @"LocationID";
			this.Columns.Add(_columnLocationID);
			
			// __LLBLGENPRO_USER_CODE_REGION_START InitClass
			// __LLBLGENPRO_USER_CODE_REGION_END
			base.ObeyWeakRelations = obeyWeakRelations;
		}


		/// <summary>Initializes the members, after a clone action.</summary>
		private void InitMembers()
		{
			_columnFieldID = this.Columns["FieldID"];
			_columnFieldName = this.Columns["FieldName"];
			_columnQuality = this.Columns["Quality"];
			_columnDescription = this.Columns["Description"];
			_columnName = this.Columns["Name"];
			_columnNumberOfFields = this.Columns["NumberOfFields"];
			_columnAddress = this.Columns["Address"];
			_columnLocationID = this.Columns["LocationID"];
			
			// __LLBLGENPRO_USER_CODE_REGION_START InitMembers
			// __LLBLGENPRO_USER_CODE_REGION_END
		}


		/// <summary>Return the type of the typed datarow</summary>
		/// <returns>returns the requested type</returns>
		protected override Type GetRowType() 
		{
			return typeof(FieldLocationRow);
		}


		/// <summary>Clones this instance.</summary>
		/// <returns>A clone of this instance</returns>
		public override DataTable Clone() 
		{
			FieldLocationTypedList cloneToReturn = ((FieldLocationTypedList)(base.Clone()));
			cloneToReturn.InitMembers();
			return cloneToReturn;
		}

#if !CF
		/// <summary>Creates a new instance of the DataTable class.</summary>
		/// <returns>a new instance of a datatable with this schema.</returns>
		protected override DataTable CreateInstance() 
		{
			return new FieldLocationTypedList();
		}
#endif

		#region Class Property Declarations
		/// <summary>Returns the amount of rows in this typed list.</summary>
		[System.ComponentModel.Browsable(false)]
		public override int Count 
		{
			get 
			{
				return this.Rows.Count;
			}
		}
		
		/// <summary>The custom properties for this TypedList type.</summary>
		/// <remarks>The data returned from this property should be considered read-only: it is not thread safe to alter this data at runtime.</remarks>
		public static Hashtable CustomProperties
		{
			get { return _customProperties;}
		}

		/// <summary>The custom properties for the type of this TypedList instance.</summary>
		/// <remarks>The data returned from this property should be considered read-only: it is not thread safe to alter this data at runtime.</remarks>
		[System.ComponentModel.Browsable(false)]
		public virtual Hashtable CustomPropertiesOfType
		{
			get { return FieldLocationTypedList.CustomProperties;}
		}

		/// <summary>The custom properties for the fields of this TypedList type. The returned Hashtable contains per fieldname a hashtable of name-value
		/// pairs. </summary>
		/// <remarks>The data returned from this property should be considered read-only: it is not thread safe to alter this data at runtime.</remarks>
		public static Hashtable FieldsCustomProperties
		{
			get { return _fieldsCustomProperties;}
		}

		/// <summary>The custom properties for the fields of the type of this TypedList instance. The returned Hashtable contains per fieldname a hashtable of name-value
		/// pairs. </summary>
		/// <remarks>The data returned from this property should be considered read-only: it is not thread safe to alter this data at runtime.</remarks>
		[System.ComponentModel.Browsable(false)]
		public virtual Hashtable FieldsCustomPropertiesOfType
		{
			get { return FieldLocationTypedList.FieldsCustomProperties;}
		}

		/// <summary>Indexer of this strong typed list</summary>
		public FieldLocationRow this[int index] 
		{
			get 
			{
				return ((FieldLocationRow)(this.Rows[index]));
			}
		}

	
		/// <summary>Returns the column object belonging to the TypedList field FieldID</summary>
		internal DataColumn FieldIDColumn 
		{
			get { return _columnFieldID; }
		}
    
		/// <summary>Returns the column object belonging to the TypedList field FieldName</summary>
		internal DataColumn FieldNameColumn 
		{
			get { return _columnFieldName; }
		}
    
		/// <summary>Returns the column object belonging to the TypedList field Quality</summary>
		internal DataColumn QualityColumn 
		{
			get { return _columnQuality; }
		}
    
		/// <summary>Returns the column object belonging to the TypedList field Description</summary>
		internal DataColumn DescriptionColumn 
		{
			get { return _columnDescription; }
		}
    
		/// <summary>Returns the column object belonging to the TypedList field Name</summary>
		internal DataColumn NameColumn 
		{
			get { return _columnName; }
		}
    
		/// <summary>Returns the column object belonging to the TypedList field NumberOfFields</summary>
		internal DataColumn NumberOfFieldsColumn 
		{
			get { return _columnNumberOfFields; }
		}
    
		/// <summary>Returns the column object belonging to the TypedList field Address</summary>
		internal DataColumn AddressColumn 
		{
			get { return _columnAddress; }
		}
    
		/// <summary>Returns the column object belonging to the TypedList field LocationID</summary>
		internal DataColumn LocationIDColumn 
		{
			get { return _columnLocationID; }
		}
    
		
		// __LLBLGENPRO_USER_CODE_REGION_START AdditionalColumnProperties
		// __LLBLGENPRO_USER_CODE_REGION_END
 		#endregion
		
		#region Custom TypedList code
		
		// __LLBLGENPRO_USER_CODE_REGION_START CustomTypedListCode
		// __LLBLGENPRO_USER_CODE_REGION_END
		#endregion

		#region Included Code

		#endregion
	}


	/// <summary>Typed datarow for the typed datatable FieldLocation</summary>
	public partial class FieldLocationRow : DataRow
		// __LLBLGENPRO_USER_CODE_REGION_START AdditionalInterfacesRow
		// __LLBLGENPRO_USER_CODE_REGION_END	
	{
		#region Class Member Declarations
		private FieldLocationTypedList	_parent;
		#endregion

		/// <summary>CTor</summary>
		/// <param name="rowBuilder">Row builder object to use when building this row</param>
		internal FieldLocationRow(DataRowBuilder rowBuilder) : base(rowBuilder) 
		{
			_parent = ((FieldLocationTypedList)(this.Table));
		}


		#region Class Property Declarations
	
		/// <summary>Gets / sets the value of the TypedList field FieldID<br/><br/>
		/// </summary>
		/// <remarks>Mapped on: Field.FieldID</remarks>
		public System.Int32 FieldID 
		{
			get 
			{
				if(IsFieldIDNull())
				{
					// return default value for this type.
					return (System.Int32)TypeDefaultValue.GetDefaultValue(typeof(System.Int32));
				}
				else
				{
					return (System.Int32)this[_parent.FieldIDColumn];
				}
			}
			set 
			{
				this[_parent.FieldIDColumn] = value;
			}
		}

		/// <summary>Returns true if the TypedList field FieldID is NULL, false otherwise.</summary>
		public bool IsFieldIDNull() 
		{
			return IsNull(_parent.FieldIDColumn);
		}

		/// <summary>Sets the TypedList field FieldID to NULL. Not recommended; a typed list should be used as a readonly object.</summary>
    	public void SetFieldIDNull() 
		{
			this[_parent.FieldIDColumn] = System.Convert.DBNull;
		}

	

		/// <summary>Gets / sets the value of the TypedList field FieldName<br/><br/>
		/// </summary>
		/// <remarks>Mapped on: Field.FieldName</remarks>
		public System.String FieldName 
		{
			get 
			{
				if(IsFieldNameNull())
				{
					// return default value for this type.
					return (System.String)TypeDefaultValue.GetDefaultValue(typeof(System.String));
				}
				else
				{
					return (System.String)this[_parent.FieldNameColumn];
				}
			}
			set 
			{
				this[_parent.FieldNameColumn] = value;
			}
		}

		/// <summary>Returns true if the TypedList field FieldName is NULL, false otherwise.</summary>
		public bool IsFieldNameNull() 
		{
			return IsNull(_parent.FieldNameColumn);
		}

		/// <summary>Sets the TypedList field FieldName to NULL. Not recommended; a typed list should be used as a readonly object.</summary>
    	public void SetFieldNameNull() 
		{
			this[_parent.FieldNameColumn] = System.Convert.DBNull;
		}

	

		/// <summary>Gets / sets the value of the TypedList field Quality<br/><br/>
		/// </summary>
		/// <remarks>Mapped on: Field.Quality</remarks>
		public System.Int32 Quality 
		{
			get 
			{
				if(IsQualityNull())
				{
					// return default value for this type.
					return (System.Int32)TypeDefaultValue.GetDefaultValue(typeof(System.Int32));
				}
				else
				{
					return (System.Int32)this[_parent.QualityColumn];
				}
			}
			set 
			{
				this[_parent.QualityColumn] = value;
			}
		}

		/// <summary>Returns true if the TypedList field Quality is NULL, false otherwise.</summary>
		public bool IsQualityNull() 
		{
			return IsNull(_parent.QualityColumn);
		}

		/// <summary>Sets the TypedList field Quality to NULL. Not recommended; a typed list should be used as a readonly object.</summary>
    	public void SetQualityNull() 
		{
			this[_parent.QualityColumn] = System.Convert.DBNull;
		}

	

		/// <summary>Gets / sets the value of the TypedList field Description<br/><br/>
		/// </summary>
		/// <remarks>Mapped on: Field.Description</remarks>
		public System.String Description 
		{
			get 
			{
				if(IsDescriptionNull())
				{
					// return default value for this type.
					return (System.String)TypeDefaultValue.GetDefaultValue(typeof(System.String));
				}
				else
				{
					return (System.String)this[_parent.DescriptionColumn];
				}
			}
			set 
			{
				this[_parent.DescriptionColumn] = value;
			}
		}

		/// <summary>Returns true if the TypedList field Description is NULL, false otherwise.</summary>
		public bool IsDescriptionNull() 
		{
			return IsNull(_parent.DescriptionColumn);
		}

		/// <summary>Sets the TypedList field Description to NULL. Not recommended; a typed list should be used as a readonly object.</summary>
    	public void SetDescriptionNull() 
		{
			this[_parent.DescriptionColumn] = System.Convert.DBNull;
		}

	

		/// <summary>Gets / sets the value of the TypedList field Name<br/><br/>
		/// </summary>
		/// <remarks>Mapped on: Location.Name</remarks>
		public System.String Name 
		{
			get 
			{
				if(IsNameNull())
				{
					// return default value for this type.
					return (System.String)TypeDefaultValue.GetDefaultValue(typeof(System.String));
				}
				else
				{
					return (System.String)this[_parent.NameColumn];
				}
			}
			set 
			{
				this[_parent.NameColumn] = value;
			}
		}

		/// <summary>Returns true if the TypedList field Name is NULL, false otherwise.</summary>
		public bool IsNameNull() 
		{
			return IsNull(_parent.NameColumn);
		}

		/// <summary>Sets the TypedList field Name to NULL. Not recommended; a typed list should be used as a readonly object.</summary>
    	public void SetNameNull() 
		{
			this[_parent.NameColumn] = System.Convert.DBNull;
		}

	

		/// <summary>Gets / sets the value of the TypedList field NumberOfFields<br/><br/>
		/// </summary>
		/// <remarks>Mapped on: Location.NumberOfFields</remarks>
		public System.Int32 NumberOfFields 
		{
			get 
			{
				if(IsNumberOfFieldsNull())
				{
					// return default value for this type.
					return (System.Int32)TypeDefaultValue.GetDefaultValue(typeof(System.Int32));
				}
				else
				{
					return (System.Int32)this[_parent.NumberOfFieldsColumn];
				}
			}
			set 
			{
				this[_parent.NumberOfFieldsColumn] = value;
			}
		}

		/// <summary>Returns true if the TypedList field NumberOfFields is NULL, false otherwise.</summary>
		public bool IsNumberOfFieldsNull() 
		{
			return IsNull(_parent.NumberOfFieldsColumn);
		}

		/// <summary>Sets the TypedList field NumberOfFields to NULL. Not recommended; a typed list should be used as a readonly object.</summary>
    	public void SetNumberOfFieldsNull() 
		{
			this[_parent.NumberOfFieldsColumn] = System.Convert.DBNull;
		}

	

		/// <summary>Gets / sets the value of the TypedList field Address<br/><br/>
		/// </summary>
		/// <remarks>Mapped on: Location.Address</remarks>
		public System.String Address 
		{
			get 
			{
				if(IsAddressNull())
				{
					// return default value for this type.
					return (System.String)TypeDefaultValue.GetDefaultValue(typeof(System.String));
				}
				else
				{
					return (System.String)this[_parent.AddressColumn];
				}
			}
			set 
			{
				this[_parent.AddressColumn] = value;
			}
		}

		/// <summary>Returns true if the TypedList field Address is NULL, false otherwise.</summary>
		public bool IsAddressNull() 
		{
			return IsNull(_parent.AddressColumn);
		}

		/// <summary>Sets the TypedList field Address to NULL. Not recommended; a typed list should be used as a readonly object.</summary>
    	public void SetAddressNull() 
		{
			this[_parent.AddressColumn] = System.Convert.DBNull;
		}

	

		/// <summary>Gets / sets the value of the TypedList field LocationID<br/><br/>
		/// </summary>
		/// <remarks>Mapped on: Location.LocationID</remarks>
		public System.Int32 LocationID 
		{
			get 
			{
				if(IsLocationIDNull())
				{
					// return default value for this type.
					return (System.Int32)TypeDefaultValue.GetDefaultValue(typeof(System.Int32));
				}
				else
				{
					return (System.Int32)this[_parent.LocationIDColumn];
				}
			}
			set 
			{
				this[_parent.LocationIDColumn] = value;
			}
		}

		/// <summary>Returns true if the TypedList field LocationID is NULL, false otherwise.</summary>
		public bool IsLocationIDNull() 
		{
			return IsNull(_parent.LocationIDColumn);
		}

		/// <summary>Sets the TypedList field LocationID to NULL. Not recommended; a typed list should be used as a readonly object.</summary>
    	public void SetLocationIDNull() 
		{
			this[_parent.LocationIDColumn] = System.Convert.DBNull;
		}

	
		#endregion

		#region Custom Typed List Row Code
		
		// __LLBLGENPRO_USER_CODE_REGION_START CustomTypedListRowCode
		// __LLBLGENPRO_USER_CODE_REGION_END
		#endregion
	}
}
